// 设置基础 URL
const API_BASE_URL = 'https://letsgoapi.intellegentfishing.cn/api';
// const API_BASE_URL = 'http://127.0.0.1:8000/api';
// 创建请求实例
// uniapp 不需要像 Axios 一样创建实例，直接使用 uni.request 即可
const apiClient = {
  baseURL: API_BASE_URL,
  request(config) {
    return new Promise((resolve, reject) => {
      uni.request({
        url: this.baseURL + config.url,  // 拼接基础 URL
        method: config.method || 'GET',  // 默认请求方法为 GET
        data: config.data || {},
        header: {
          'Content-Type': 'application/json',
          ...config.headers,  // 合并额外的请求头
        },
        success: (res) => {
          if (res.statusCode === 200) {
            resolve(res.data);  // 请求成功，返回数据
          } else {
            reject(res);  // 请求失败，返回错误信息
          }
        },
        fail: (err) => {
          reject(err);  // 请求失败，返回错误信息
        },
      });
    });
  },
};
export const OrderAPI= {
  // 发号施令
  getOrder() {
    return apiClient.request({ url: '/order/', method: 'GET' });
  },
  async fetchOrderData() {
	let iv=false;
	try {
	  const res = await this.getOrder();
	  if (res.message == '1') {
		  console.log('method1');
		iv = true;
	  } else {
		iv = false;
	  }
	} catch (error) {
	  iv = false; 
	}
		return iv;
  },
}
//{
	// 'message':'1' 表示可以显示 0表示不可以显示
// }

// 用户接口
// api/user.js
export const UserAPI = {
  // 获取所有用户
  getUsers() {
    return apiClient.request({ url: '/users/', method: 'GET' });
  },

  // 根据 ID 获取用户
  getUserById(userId) {
    return apiClient.request({ url: `/users/${userId}/`, method: 'GET' });
  },

  // 创建新用户
  createUser(userData) {
    return apiClient.request({ url: '/users/', method: 'POST', data: userData });
  },

  // 更新用户信息
  updateUser(userId, userData) {
    return apiClient.request({ url: `/users/${userId}/`, method: 'PUT', data: userData });
  },

  // 删除用户
  deleteUser(userId) {
    return apiClient.request({ url: `/users/${userId}/`, method: 'DELETE' });
  },

  // 微信登录
  wechatLogin(code) {
    return apiClient.request({
      url: '/users/wechat_login/', // 后端接口地址
      method: 'POST',
      data: { code: code },
    });
  }
};



export const SessionAPI = {
  // 获取所有会话记录
  getSessions() {
    return apiClient.request({
      url: '/sessions/',
      method: 'GET',
    });
  },

  // 根据会话 Value 获取单个会话记录
  getSessionByValue(sessionValue) {
    return apiClient.request({
      url: `/sessions/${sessionValue}/`,
      method: 'GET',
    });
  },

  // 根据用户 ID 获取会话记录
  getSessionsByUser(userId) {
    return apiClient.request({
      url: `/sessions/?user_id=${userId}`,
      method: 'GET',
    });
  },

  // 创建新会话
  createSession(sessionData) {
    return apiClient.request({
      url: '/sessions/',
      method: 'POST',
      data: sessionData,
    });
  },

  // 更新会话记录
  updateSession(sessionValue, sessionData) {
    return apiClient.request({
      url: `/sessions/${sessionValue}/`,
      method: 'PUT',
      data: sessionData,
    });
  },

  // 删除会话记录
  deleteSession(sessionValue) {
    return apiClient.request({
      url: `/sessions/${sessionValue}/`,
      method: 'DELETE',
    });
  },
};
/**
 * 根据 sessionValue 获取用户信息
 * @returns {Promise} - 返回用户信息
 */
export const getUserInfo = async () => {
  try {
    // 获取缓存中的 sessionValue
    const sessionValue = uni.getStorageSync('sessionValue');

    if (!sessionValue) {
      throw new Error('Session value not found in cache');
    }

    // 根据 sessionValue 查询会话记录
    const sessionResponse = await SessionAPI.getSessionByValue(sessionValue);
	console.log(sessionResponse);
    // 从会话记录中获取 userId
    const userId = sessionResponse.userID;

    if (!userId) {
      throw new Error('User ID not found in session data');
    }

    return sessionResponse;
  } catch (error) {
    console.error('Error fetching user info:', error);
    throw error;  // 抛出错误以便调用者处理
  }
};
        // getUserInfo()
        //   .then(userInfo => {
        //     console.log('User Info:', userInfo);
        //   })
        //   .catch(error => {
        //     console.error('Failed to fetch user info:', error);
        //   });


// 验证码接口 API
export const VerificationCodeAPI = {
  /**
   * 获取验证码列表
   * @param {string|null} phoneNumber - 可选参数，用于通过手机号过滤验证码
   * @returns {Promise} - 返回验证码数据
   */
  getCodes(phoneNumber = null) {
    const url = phoneNumber
      ? `/verification_codes/?phoneNumber=${phoneNumber}`
      : '/verification_codes/';
    return apiClient.request({ url, method: 'GET' });
  },

  /**
   * 创建验证码
   * @param {string} phoneNumber - 手机号，用于发送验证码
   * @returns {Promise} - 返回创建结果
   */
  createCode(phoneNumber) {
    return apiClient.request({
      url: '/verification_codes/',
      method: 'POST',
      data: { phoneNumber },
    });
  },

  /**
   * 验证验证码
   * @param {Object} data - 包括手机号phoneNumber和验证码code的对象
   * @returns {Promise} - 返回验证结果
   */
  verifyCode(data) {
    return apiClient.request({
      url: '/verification_codes/verify/',
      method: 'POST',
      data,
    });
  },
// 返回格式：{
//     "message": "Login successful",
//     "user": {
//         "userID": 4,
//         "username": "user_7403",
//         "email": null,
//         "phoneNumber": "15820647403",
//         "creditRating": 0,
//         "isVerified": 1,
//         "sessionValue": "2ce5b19040bf5cb283c83420f430ea3b5337acd8db879c91bcd7c242f8a9518b"
//     }
// }
  /**
   * 更新验证码状态
   * @param {number} codeId - 验证码的唯一 ID
   * @returns {Promise} - 返回更新结果
   */
  updateCode(codeId) {
    return apiClient.request({
      url: `/verification_codes/${codeId}/`,
      method: 'PUT',
    });
  },

  /**
   * 删除验证码
   * @param {number} codeId - 验证码的唯一 ID
   * @returns {Promise} - 返回删除结果
   */
  deleteCode(codeId) {
    return apiClient.request({
      url: `/verification_codes/${codeId}/`,
      method: 'DELETE',
    });
  },
};


// 拼车接口
export const PinlistAPI = {
  getPinlists() {
    return apiClient.request({ url: '/pinlists/', method: 'GET' });
  },
  getPinById(pinId) {
    return apiClient.request({ url: `/pinlists/${pinId}/`, method: 'GET' });
  },
  createPin(pinData) {
    return apiClient.request({ url: '/pinlists/', method: 'POST', data: pinData });
  },
  updatePin(pinId, pinData) {
    return apiClient.request({ url: `/pinlists/${pinId}/`, method: 'PUT', data: pinData });
  },
  deletePin(pinId) {
    return apiClient.request({ url: `/pinlists/${pinId}/`, method: 'DELETE' });
  },
  addMember(pinID,userID){
	  return apiClient.request({ url: '/pinlists/addMember/', method: 'POST', data: {'pinID':pinID,'userID':userID} });
  },
  removeMember(pinID,userID){
	  return apiClient.request({ url: '/pinlists/removeMember/', method: 'POST', data: {'pinID':pinID,'userID':userID} });
  }
};

// 聊天记录接口
export const ChatAPI = {
  // 获取所有聊天记录
  getChats() {
    return apiClient.request({ url: '/chat/', method: 'GET' });
  },

  // 根据用户 ID 获取聊天记录
  getChatsByUser(userId) {
    return apiClient.request({ url: `/chat/?user_id=${userId}`, method: 'GET' });
  },

  // 根据 pinID 获取聊天记录
  getChatsByPin(pinId) {
    return apiClient.request({ url: `/chat/?pin_id=${pinId}`, method: 'GET' });
  },

  // 获取单条聊天记录
  getChatById(messageId) {
    return apiClient.request({ url: `/chat/${messageId}/`, method: 'GET' });
  },

  // 创建新聊天记录
  createChat(chatData) {
    return apiClient.request({ url: '/chat/', method: 'POST', data: chatData });
  },

  // 更新聊天记录
  updateChat(messageId, chatData) {
    return apiClient.request({ url: `/chat/${messageId}/`, method: 'PUT', data: chatData });
  },

  // 删除聊天记录
  deleteChat(messageId) {
    return apiClient.request({ url: `/chat/${messageId}/`, method: 'DELETE' });
  },
};

export const ComplaintAPI = {
  // 获取所有投诉记录
  getComplaints() {
    return apiClient.request({
      url: '/complaints/',
      method: 'GET',
    });
  },

  // 根据投诉 ID 获取单个投诉记录
  getComplaintById(complaintId) {
    return apiClient.request({
      url: `/complaints/${complaintId}/`,
      method: 'GET',
    });
  },

  // 根据用户 ID 获取所有投诉记录
  getComplaintsByUser(userId) {
    return apiClient.request({
      url: '/complaints/',
      method: 'GET',
    });
  },

  // 创建新的投诉记录
  createComplaint(complaintData) {
    return apiClient.request({
      url: '/complaints/',
      method: 'POST',
      data: complaintData,
    });
  },

  // 更新指定的投诉记录
  updateComplaint(complaintId, complaintData) {
    return apiClient.request({
      url: `/complaints/${complaintId}/`,
      method: 'PUT',
      data: complaintData,
    });
  },

  // 删除指定的投诉记录
  deleteComplaint(complaintId) {
    return apiClient.request({
      url: `/complaints/${complaintId}/`,
      method: 'DELETE',
    });
  },
};

// user 表：
// CREATE TABLE user (
//     userID INT AUTO_INCREMENT PRIMARY KEY,  -- 用户ID，自增主键
//     username VARCHAR(255) NOT NULL,         -- 用户名，非空
//     creditRating INT,                      -- 信用评级
//     name VARCHAR(255),                     -- 姓名
//     gender ENUM('Male', 'Female', 'Other'), -- 性别，枚举类型
//     birthday DATE,                          -- 生日
//     isVerified BOOLEAN,                     -- 是否认证，布尔值
//     email VARCHAR(255) UNIQUE,              -- 邮箱，唯一
//     password VARCHAR(255),                  -- 密码
//     phoneNumber VARCHAR(20) UNIQUE          -- 手机号码，唯一
//     openid VARCHAR(255) --微信openid
// );
// verification_code 表：
// CREATE TABLE verification_code (
//     codeID INT AUTO_INCREMENT PRIMARY KEY,  -- 验证码ID，自增主键
//     phoneNumber VARCHAR(20),                -- 手机号码，外键，关联 user 表
//     code CHAR(6),                           -- 验证码内容，6位数字字符
//     expirationTime DATETIME,                -- 验证码的过期时间
//     createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,  -- 验证码生成时间，默认当前时间
//     isUsed BOOLEAN,                         -- 是否已使用，布尔值
// );

// 拼车接口
// CREATE TABLE pinlist (
//   pinID INT AUTO_INCREMENT PRIMARY KEY,          -- 拼车单ID，自增主键
//   leader INT,                                    -- 团长用户ID，外键，关联 user 表
//   members TEXT,                                  -- 成员用户ID列表，存储为字符串或JSON数组
//   startPoint VARCHAR(255),                       -- 起点
//   endPoint VARCHAR(255),                         -- 终点
//   departureTime DATETIME,                        -- 出发时间
//   arrivalTime DATETIME,                          -- 到达时间
//   totalPassengers INT NOT NULL DEFAULT 0,        -- 总共可用的拼车位置，默认值为0
//   joinedPassengers INT NOT NULL DEFAULT 0,       -- 已加入的人数，默认值为0
//   FOREIGN KEY (leader) REFERENCES user (userID)  -- 外键，关联 user 表的 userID
// );

// chat 表：
// CREATE TABLE chat (
//     messageID INT AUTO_INCREMENT PRIMARY KEY, -- 消息ID，自增主键
//     pinID INT,                                -- 所属拼车单ID，外键，关联 pinlist 表
//     userID INT,                               -- 发言用户ID，外键，关联 user 表
//     messageTime TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- 发言时间，默认当前时间
//     messageContent TEXT,                      -- 消息内容
//     FOREIGN KEY (pinID) REFERENCES pinlist (pinID), -- 外键，关联 pinlist 表
//     FOREIGN KEY (userID) REFERENCES user (userID)   -- 外键，关联 user 表的 userID
// );

// session表:
// CREATE TABLE session (
//     sessionID INT AUTO_INCREMENT PRIMARY KEY,       -- 会话ID，自增主键
//     sessionValue CHAR(64) NOT NULL,                  -- 会话值，通常是一个随机生成的唯一令牌
//     userID INT NOT NULL,                             -- 关联的用户ID，外键，关联 user 表
//     createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,   -- 会话创建时间，默认当前时间
//     lastAccessedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,  -- 会话最后访问时间
//     isActive BOOLEAN DEFAULT TRUE,                   -- 会话是否有效，默认为有效
//     FOREIGN KEY (userID) REFERENCES user(userID)     -- 外键，关联 user 表的 userID
// );

// complaint表
// CREATE TABLE complaint (
//     complaintID INT AUTO_INCREMENT PRIMARY KEY,   -- 投诉ID，自增主键
//     userID INT,                                  -- 用户ID，外键关联user表
//     complaintType VARCHAR(255) NOT NULL,          -- 投诉类型
//     complaintReason TEXT NOT NULL,               -- 投诉原因
//     complaintTime TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- 投诉时间，默认当前时间
//     pinID VARCHAR(255),                    -- 投诉拼单号
//     FOREIGN KEY (userID) REFERENCES user(userID) -- 外键约束，关联user表的userID
// );
